Baseline (base)
[+]
[-]
Profile Specification
[-]
[+]
origin
979c7050f9d06b2796bffc995a3031dbc9a9dea6
command
./compare_traces inputs/minimal-baseline.txt inputs/minimal-target.txt
collector command
kperf --repeat=1 --warmup=3
kernel
5.15.146.1-microsoft-standard-WSL2
boot info
initrd=\initrd.img WSL_ROOT_INIT=1 panic=-1 nr_cpus=12 hv_utils.timesync_implicit=1 console=hvc0 debug pty.legacy_count=0
host
dellion
cpu (total)
12
memory (total)
7.7 GiB
Target (tgt)
[+]
[-]
Profile Specification
[-]
[+]
origin
979c7050f9d06b2796bffc995a3031dbc9a9dea6
command
./compare_traces inputs/minimal-baseline.txt inputs/minimal-target.txt
collector command
kperf --repeat=1 --warmup=3
kernel
5.15.146.1-microsoft-standard-WSL2
boot info
initrd=\initrd.img WSL_ROOT_INIT=1 panic=-1 nr_cpus=12 hv_utils.timesync_implicit=1 console=hvc0 debug pty.legacy_count=0
host
dellion
cpu (total)
12
memory (total)
7.7 GiB
Top Inclusive Samples [#]
Browse All
[+]
[-]
Help / Tips
[-]
[+]
Tip 1
Click on a row to explore the results in a form of Sankey Graph (below the table).
Tip 2
Click on [+] to open a detailed report about concrete calling contexts.
Tip 3
Filter the results through select form on the bottom of table (for selected columns).
Unit
Change
Metric
Absolute Difference
Relative Difference
Search:
[+]
[-]
Help / Tips
[-]
[+]
Tip 1
Look for the topmost widest rectangle.
Tip 2
Click on the node to explore the results in a form of Sankey Graph (below the table).
Tip 3
Colours are picked randomly (but uniformly); they don't signal any scale.
Tip 4
The bigger the rectangle the more often the UID was seen on the stack.
Tip 5
The higher the flame the more nested calls were made in the context.
Baseline Flamegraph
Reset Zoom
Search
ic
std::__uninitialized_fill_n<>::__uninit_fill_n<> (1,280,423,196 samples, 0.63%)
std::_Destroy<> (586,679,195 samples, 0.29%)
std::_Destroy_aux<>::__destroy<> (422,919,993 samples, 0.21%)
std::copy<> (966,342,253 samples, 0.47%)
std::__cxx11::basic_string<>::operator[] (795,459,911 samples, 0.39%)
std::min<> (12,862,960,168 samples, 6.29%)
std..
std::_Construct<> (3,242,615,695 samples, 1.59%)
std::__copy_move_a<> (734,784,789 samples, 0.36%)
levenshteinDistance (35,967,247,589 samples, 17.59%)
levenshteinD..
std::uninitialized_fill_n<> (3,686,183,892 samples, 1.80%)
switch_cost_levenshtein (8,737,653,519 samples, 4.27%)
s..
std::_Vector_base<>::_M_create_storage (439,708,684 samples, 0.22%)
std::min_element<> (7,589,016,500 samples, 3.71%)
s..
std::vector<>::~vector (1,618,515,240 samples, 0.79%)
__gnu_cxx::__ops::_Iter_less_iter::operator (3,159,309,247 samples, 1.55%)
std::min_element<> (416,617,223 samples, 0.20%)
computeTransformationCost (107,185,586,856 samples, 52.42%)
computeTransformationCost
levenshteinDistance (15,425,488,826 samples, 7.54%)
leve..
std::copy<> (889,550,564 samples, 0.44%)
std::uninitialized_copy<> (1,053,130,023 samples, 0.52%)
std::__min_element<> (6,439,788,565 samples, 3.15%)
levenshteinDistance (7,952,386,064 samples, 3.89%)
l..
std::min<> (13,406,973,196 samples, 6.56%)
std..
std::__uninitialized_fill_n_a<> (2,938,024,094 samples, 1.44%)
std::__cxx11::basic_string<>::operator[] (738,601,691 samples, 0.36%)
std::vector<>::_M_fill_initialize (3,391,612,488 samples, 1.66%)
std::_Destroy<> (1,566,171,438 samples, 0.77%)
std::initializer_list<>::begin (372,195,237 samples, 0.18%)
switch_cost_levenshtein (9,381,133,234 samples, 4.59%)
s..
std::initializer_list<>::end (1,010,482,878 samples, 0.49%)
std::min_element<> (4,163,328,960 samples, 2.04%)
__gnu_cxx::__ops::_Iter_less_iter::operator (3,098,806,293 samples, 1.52%)
std::min<> (569,181,998 samples, 0.28%)
std::min_element<> (365,429,441 samples, 0.18%)
std::__cxx11::basic_string<>::operator[] (469,622,018 samples, 0.23%)
std::__copy_move_a2<> (450,121,758 samples, 0.22%)
std::__uninitialized_copy_a<> (507,492,186 samples, 0.25%)
std::vector<>::vector (754,490,841 samples, 0.37%)
switch_cost_levenshtein (21,493,029,798 samples, 10.51%)
switch..
std::vector<>::~vector (759,350,899 samples, 0.37%)
std::__min_element<> (426,007,826 samples, 0.21%)
std::copy<> (739,131,066 samples, 0.36%)
std::__uninitialized_copy<>::__uninit_copy<> (469,209,327 samples, 0.23%)
std::vector<>::~vector (637,083,650 samples, 0.31%)
std::__cxx11::basic_string<>::operator[] (356,222,314 samples, 0.17%)
std::vector<>::operator[] (4,508,805,656 samples, 2.21%)
std::vector<>::vector (1,863,815,407 samples, 0.91%)
std::__min_element<> (354,505,654 samples, 0.17%)
computeTransformationCost (67,753,997,553 samples, 33.14%)
computeTransformationCost
std::vector<>::vector (601,542,119 samples, 0.29%)
std::__min_element<> (423,789,392 samples, 0.21%)
std::initializer_list<>::end (437,642,544 samples, 0.21%)
computeTransformationCost (200,784,242,465 samples, 98.20%)
computeTransformationCost
std::vector<>::_M_fill_initialize (1,838,381,791 samples, 0.90%)
std::__uninitialized_fill_n<>::__uninit_fill_n<> (2,914,891,732 samples, 1.43%)
std::vector<>::vector (3,390,724,445 samples, 1.66%)
std::min_element<> (2,035,262,262 samples, 1.00%)
__libc_start_call_main (200,835,020,527 samples, 98.22%)
__libc_start_call_main
std::vector<>::~vector (697,866,145 samples, 0.34%)
std::uninitialized_copy<> (482,108,459 samples, 0.24%)
std::vector<>::operator[] (2,959,639,036 samples, 1.45%)
std::vector<>::~vector (958,792,138 samples, 0.47%)
std::_Destroy<> (1,492,811,925 samples, 0.73%)
std::vector<>::~vector (1,098,039,841 samples, 0.54%)
std::__copy_move_a1<> (402,206,259 samples, 0.20%)
std::__uninitialized_fill_n<>::__uninit_fill_n<> (3,690,975,605 samples, 1.81%)
std::initializer_list<>::end (563,472,158 samples, 0.28%)
std::__copy_move_a1<> (498,238,677 samples, 0.24%)
std::initializer_list<>::size (398,383,052 samples, 0.19%)
std::__uninitialized_fill_n_a<> (1,696,786,889 samples, 0.83%)
levenshteinDistance (1,425,345,925 samples, 0.70%)
std::vector<>::operator[] (1,107,911,229 samples, 0.54%)
std::_Construct<> (690,862,681 samples, 0.34%)
std::vector<>::operator[] (1,648,622,910 samples, 0.81%)
std::__uninitialized_copy_a<> (1,172,810,328 samples, 0.57%)
std::_Destroy<> (1,292,226,787 samples, 0.63%)
std::__min_element<> (4,922,758,928 samples, 2.41%)
std::__uninitialized_fill_n_a<> (716,219,448 samples, 0.35%)
std::_Destroy<> (586,679,195 samples, 0.29%)
std::_Destroy_aux<>::__destroy<> (574,917,530 samples, 0.28%)
std::_Destroy<> (857,134,759 samples, 0.42%)
std::__min_element<> (372,116,456 samples, 0.18%)
std::initializer_list<>::begin (947,197,643 samples, 0.46%)
levenshteinDistance (8,649,590,570 samples, 4.23%)
l..
std::__copy_move_a<> (666,103,556 samples, 0.33%)
computeTransformationCost (1,562,828,843 samples, 0.76%)
computeTransformationCost (31,943,472,889 samples, 15.62%)
computeTra..
std::uninitialized_fill_n<> (1,306,098,840 samples, 0.64%)
main (200,835,020,527 samples, 98.22%)
main
std::__uninitialized_fill_n<>::__uninit_fill_n<> (3,353,218,785 samples, 1.64%)
std::uninitialized_copy<> (971,602,485 samples, 0.48%)
std::min<> (8,374,262,242 samples, 4.10%)
s..
std::min<> (1,694,274,223 samples, 0.83%)
std::vector<>::~vector (1,679,892,849 samples, 0.82%)
std::_Vector_base<>::~_Vector_base (785,461,231 samples, 0.38%)
std::vector<>::_M_fill_initialize (716,219,448 samples, 0.35%)
std::_Construct<> (3,576,983,418 samples, 1.75%)
std::initializer_list<>::end (848,709,221 samples, 0.42%)
std::_Vector_base<>::_Vector_base (947,315,020 samples, 0.46%)
std::_Construct<> (2,820,181,631 samples, 1.38%)
std::vector<>::vector (1,443,583,288 samples, 0.71%)
std::vector<>::operator[] (4,141,188,455 samples, 2.03%)
std::initializer_list<>::end (925,345,929 samples, 0.45%)
std::_Destroy<> (492,201,982 samples, 0.24%)
std::__min_element<> (3,596,444,207 samples, 1.76%)
std::vector<>::vector (2,544,481,192 samples, 1.24%)
std::_Construct<> (1,242,342,738 samples, 0.61%)
std::__uninitialized_fill_n_a<> (3,378,911,474 samples, 1.65%)
std::_Destroy_aux<>::__destroy<> (1,447,713,658 samples, 0.71%)
std::__min_element<> (4,381,830,163 samples, 2.14%)
std::_Vector_base<>::~_Vector_base (476,732,929 samples, 0.23%)
std::vector<>::vector (4,225,672,853 samples, 2.07%)
std::min_element<> (1,084,929,820 samples, 0.53%)
std::_Destroy_aux<>::__destroy<> (1,477,142,706 samples, 0.72%)
switch_cost_levenshtein (25,694,370,319 samples, 12.57%)
switch_c..
std::vector<>::operator[] (1,849,714,472 samples, 0.90%)
std::_Destroy<> (1,198,382,917 samples, 0.59%)
std::uninitialized_fill_n<> (3,378,911,474 samples, 1.65%)
switch_cost_levenshtein (4,703,449,761 samples, 2.30%)
__gnu_cxx::__ops::_Iter_less_iter::operator (2,409,171,206 samples, 1.18%)
std::_Destroy<> (434,236,213 samples, 0.21%)
__gnu_cxx::__ops::_Iter_less_iter::operator (1,805,564,101 samples, 0.88%)
std::min_element<> (4,957,997,490 samples, 2.42%)
__gnu_cxx::__ops::_Iter_less_iter::operator (394,624,181 samples, 0.19%)
std::vector<>::vector (1,168,214,478 samples, 0.57%)
computeTransformationCost (199,660,074,606 samples, 97.65%)
computeTransformationCost
std::initializer_list<>::begin (385,884,757 samples, 0.19%)
std::min<> (359,127,570 samples, 0.18%)
std::__uninitialized_copy_a<> (900,462,166 samples, 0.44%)
levenshteinDistance (30,598,413,605 samples, 14.96%)
levenshtei..
std::uninitialized_copy<> (1,079,281,697 samples, 0.53%)
std::_Destroy<> (845,476,601 samples, 0.41%)
std::vector<>::vector (702,358,987 samples, 0.34%)
std::__uninitialized_fill_n_a<> (1,306,098,840 samples, 0.64%)
std::__uninitialized_copy_a<> (1,097,740,510 samples, 0.54%)
std::_Destroy<> (1,132,839,209 samples, 0.55%)
std::initializer_list<>::size (369,093,932 samples, 0.18%)
std::__copy_move_a<> (748,194,474 samples, 0.37%)
std::__uninitialized_fill_n<>::__uninit_fill_n<> (3,638,242,600 samples, 1.78%)
std::vector<>::operator[] (352,572,419 samples, 0.17%)
std::_Destroy<> (747,257,873 samples, 0.37%)
std::vector<>::~vector (749,097,939 samples, 0.37%)
__gnu_cxx::__ops::_Iter_less_iter::operator (779,618,259 samples, 0.38%)
std::vector<>::~vector (470,781,751 samples, 0.23%)
std::initializer_list<>::end (371,234,918 samples, 0.18%)
std::_Construct<> (1,716,503,467 samples, 0.84%)
computeTransformationCost (10,324,309,168 samples, 5.05%)
co..
std::__min_element<> (899,045,497 samples, 0.44%)
std::__uninitialized_copy_a<> (1,116,085,066 samples, 0.55%)
std::__cxx11::basic_string<>::operator[] (603,097,122 samples, 0.29%)
std::__uninitialized_fill_n_a<> (638,640,385 samples, 0.31%)
std::min<> (3,104,729,312 samples, 1.52%)
std::copy<> (464,197,899 samples, 0.23%)
std::vector<>::_M_fill_initialize (638,640,385 samples, 0.31%)
std::min<> (5,757,486,021 samples, 2.82%)
std::__uninitialized_fill_n<>::__uninit_fill_n<> (716,219,448 samples, 0.35%)
std::uninitialized_copy<> (367,552,026 samples, 0.18%)
std::vector<>::vector (1,568,790,170 samples, 0.77%)
std::min<> (7,371,209,206 samples, 3.60%)
computeTransformationCost (200,835,020,527 samples, 98.22%)
computeTransformationCost
std::uninitialized_fill_n<> (716,219,448 samples, 0.35%)
computeTransformationCost (200,458,629,952 samples, 98.04%)
computeTransformationCost
std::initializer_list<>::end (365,072,314 samples, 0.18%)
std::_Vector_base<>::_Vector_base (408,999,057 samples, 0.20%)
std::vector<>::~vector (466,837,982 samples, 0.23%)
std::__uninitialized_fill_n<>::__uninit_fill_n<> (1,813,209,676 samples, 0.89%)
__gnu_cxx::__ops::_Iter_less_iter::operator (365,532,162 samples, 0.18%)
std::min_element<> (390,869,423 samples, 0.19%)
findBestCorrespondingTraces (200,835,020,527 samples, 98.22%)
findBestCorrespondingTraces
_int_free (373,024,788 samples, 0.18%)
std::vector<>::vector (1,500,289,410 samples, 0.73%)
std::initializer_list<>::end (1,411,963,460 samples, 0.69%)
std::_Vector_base<>::_M_create_storage (397,673,642 samples, 0.19%)
computeTransformationCost (200,809,636,724 samples, 98.21%)
computeTransformationCost
std::min<> (634,887,072 samples, 0.31%)
std::_Destroy<> (882,926,059 samples, 0.43%)
std::_Vector_base<>::_M_create_storage (563,240,974 samples, 0.28%)
std::vector<>::_M_fill_initialize (3,765,884,457 samples, 1.84%)
std::_Construct<> (1,633,535,127 samples, 0.80%)
std::_Vector_base<>::~_Vector_base (475,745,185 samples, 0.23%)
std::_Destroy<> (372,930,963 samples, 0.18%)
computeTransformationCost (200,722,600,854 samples, 98.17%)
computeTransformationCost
std::__uninitialized_fill_n_a<> (1,838,381,791 samples, 0.90%)
switch_cost_levenshtein (798,555,346 samples, 0.39%)
std::_Destroy<> (434,236,213 samples, 0.21%)
std::__copy_move_a1<> (383,413,368 samples, 0.19%)
computeTransformationCost (140,729,208,100 samples, 68.83%)
computeTransformationCost
std::uninitialized_fill_n<> (1,696,786,889 samples, 0.83%)
levenshteinDistance (19,565,361,715 samples, 9.57%)
leven..
std::min_element<> (5,613,899,467 samples, 2.75%)
std::min_element<> (8,836,314,659 samples, 4.32%)
s..
std::_Destroy<> (1,473,030,617 samples, 0.72%)
std::_Vector_base<>::_Vector_base (480,323,572 samples, 0.23%)
std::__uninitialized_copy<>::__uninit_copy<> (978,103,656 samples, 0.48%)
computeTransformationCost (200,835,020,527 samples, 98.22%)
computeTransformationCost
std::__uninitialized_copy_a<> (427,966,397 samples, 0.21%)
std::vector<>::~vector (1,127,610,139 samples, 0.55%)
std::vector<>::operator[] (1,405,362,643 samples, 0.69%)
std::_Destroy_aux<>::__destroy<> (845,476,601 samples, 0.41%)
computeTransformationCost (166,536,640,667 samples, 81.45%)
computeTransformationCost
std::_Vector_base<>::_Vector_base (616,532,133 samples, 0.30%)
std::__copy_move_a<> (600,262,400 samples, 0.29%)
__gnu_cxx::__ops::_Iter_less_iter::operator (1,266,915,808 samples, 0.62%)
std::vector<>::vector (3,233,151,549 samples, 1.58%)
std::min_element<> (9,066,858,798 samples, 4.43%)
s..
std::vector<>::operator[] (711,021,019 samples, 0.35%)
levenshteinDistance (32,637,225,855 samples, 15.96%)
levenshtein..
std::_Destroy<> (1,591,747,717 samples, 0.78%)
computeTransformationCost (183,368,024,803 samples, 89.68%)
computeTransformationCost
__gnu_cxx::__ops::_Iter_less_iter::operator (501,253,148 samples, 0.25%)
std::__uninitialized_copy<>::__uninit_copy<> (1,028,242,590 samples, 0.50%)
switch_cost_levenshtein (33,386,198,266 samples, 16.33%)
switch_cost..
_int_malloc (1,002,329,063 samples, 0.49%)
std::_Destroy_aux<>::__destroy<> (1,070,746,899 samples, 0.52%)
std::vector<>::operator[] (396,683,732 samples, 0.19%)
std::vector<>::_M_fill_initialize (1,306,098,840 samples, 0.64%)
computeTransformationCost (200,835,020,527 samples, 98.22%)
computeTransformationCost
std::__uninitialized_copy<>::__uninit_copy<> (813,732,588 samples, 0.40%)
std::vector<>::operator[] (1,357,119,625 samples, 0.66%)
std::uninitialized_fill_n<> (2,938,024,094 samples, 1.44%)
std::__min_element<> (7,949,696,543 samples, 3.89%)
s..
std::vector<>::operator[] (882,298,208 samples, 0.43%)
std::vector<>::_M_fill_initialize (1,722,138,173 samples, 0.84%)
std::vector<>::operator[] (391,024,515 samples, 0.19%)
std::_Construct<> (638,640,385 samples, 0.31%)
std::_Destroy<> (1,113,180,448 samples, 0.54%)
std::__min_element<> (1,880,467,064 samples, 0.92%)
std::__cxx11::basic_string<>::operator[] (392,038,099 samples, 0.19%)
__gnu_cxx::__ops::_Iter_less_iter::operator (1,592,108,512 samples, 0.78%)
levenshteinDistance (4,376,181,830 samples, 2.14%)
std::__min_element<> (1,732,749,231 samples, 0.85%)
computeTransformationCost (192,838,126,452 samples, 94.31%)
computeTransformationCost
std::__uninitialized_fill_n<>::__uninit_fill_n<> (1,684,052,101 samples, 0.82%)
[compare_traces] (422,861,827 samples, 0.21%)
std::vector<>::vector (2,061,789,124 samples, 1.01%)
std::_Vector_base<>::~_Vector_base (496,273,355 samples, 0.24%)
std::vector<>::~vector (1,265,904,027 samples, 0.62%)
std::_Destroy<> (1,120,131,048 samples, 0.55%)
switch_cost_levenshtein (39,153,081,818 samples, 19.15%)
switch_cost_l..
std::vector<>::_M_fill_initialize (3,698,851,956 samples, 1.81%)
std::__uninitialized_copy<>::__uninit_copy<> (489,568,699 samples, 0.24%)
std::_Vector_base<>::_M_create_storage (605,668,683 samples, 0.30%)
std::vector<>::vector (3,232,903,154 samples, 1.58%)
levenshteinDistance (1,957,877,249 samples, 0.96%)
[unknown] (1,074,105,939 samples, 0.53%)
switch_cost_levenshtein (2,080,488,675 samples, 1.02%)
std::initializer_list<>::begin (652,398,489 samples, 0.32%)
std::min<> (3,319,605,346 samples, 1.62%)
std::__uninitialized_copy_a<> (552,469,846 samples, 0.27%)
std::__copy_move_a1<> (519,189,592 samples, 0.25%)
std::vector<>::operator[] (6,254,153,350 samples, 3.06%)
std::_Vector_base<>::_Vector_base (995,618,761 samples, 0.49%)
levenshteinDistance (23,611,028,875 samples, 11.55%)
levensh..
std::__uninitialized_fill_n<>::__uninit_fill_n<> (638,640,385 samples, 0.31%)
malloc (851,359,263 samples, 0.42%)
std::_Destroy_aux<>::__destroy<> (1,050,080,596 samples, 0.51%)
std::vector<>::vector (3,681,010,128 samples, 1.80%)
std::copy<> (443,884,098 samples, 0.22%)
std::vector<>::vector (352,568,529 samples, 0.17%)
switch_cost_levenshtein (1,537,987,658 samples, 0.75%)
std::min_element<> (2,242,546,572 samples, 1.10%)
computeTransformationCost (197,566,874,147 samples, 96.62%)
computeTransformationCost
std::vector<>::~vector (1,290,759,638 samples, 0.63%)
std::vector<>::_M_fill_initialize (2,938,024,094 samples, 1.44%)
std::__uninitialized_fill_n_a<> (3,715,810,179 samples, 1.82%)
std::uninitialized_fill_n<> (1,838,381,791 samples, 0.90%)
std::vector<>::vector (2,960,469,343 samples, 1.45%)
std::vector<>::operator[] (6,718,256,802 samples, 3.29%)
computeTransformationCost (200,835,020,527 samples, 98.22%)
computeTransformationCost
std::uninitialized_copy<> (489,568,699 samples, 0.24%)
std::vector<>::vector (4,122,546,291 samples, 2.02%)
std::min_element<> (446,367,145 samples, 0.22%)
std::vector<>::operator[] (1,598,306,514 samples, 0.78%)
std::copy<> (896,341,166 samples, 0.44%)
std::_Vector_base<>::_Vector_base (673,236,460 samples, 0.33%)
std::__uninitialized_copy<>::__uninit_copy<> (922,596,911 samples, 0.45%)
std::_Destroy<> (1,138,306,614 samples, 0.56%)
switch_cost_levenshtein (35,683,728,023 samples, 17.45%)
switch_cost_..
std::__copy_move_a2<> (457,869,211 samples, 0.22%)
std::initializer_list<>::end (1,475,503,134 samples, 0.72%)
std::__uninitialized_fill_n_a<> (3,686,183,892 samples, 1.80%)
std::uninitialized_copy<> (877,364,367 samples, 0.43%)
std::uninitialized_fill_n<> (638,640,385 samples, 0.31%)
std::vector<>::operator[] (1,075,222,396 samples, 0.53%)
all (204,472,029,123 samples, 100%)
std::vector<>::vector (602,439,102 samples, 0.29%)
std::min<> (10,501,207,091 samples, 5.14%)
st..
std::_Destroy<> (858,096,978 samples, 0.42%)
_int_free (950,953,278 samples, 0.47%)
std::__min_element<> (7,756,750,154 samples, 3.79%)
s..
computeTransformationCost (200,835,020,527 samples, 98.22%)
computeTransformationCost
std::_Construct<> (3,539,270,277 samples, 1.73%)
levenshteinDistance (785,597,836 samples, 0.38%)
switch_cost_levenshtein (16,742,814,514 samples, 8.19%)
swit..
std::uninitialized_fill_n<> (3,703,566,980 samples, 1.81%)
std::vector<>::operator[] (5,929,020,099 samples, 2.90%)
std::_Vector_base<>::~_Vector_base (763,609,430 samples, 0.37%)
Target Flamegraph
Reset Zoom
Search
ic
std::_Hashtable<>::_M_find_node (86,104,062 samples, 0.28%)
std::_Hashtable<>::_Hashtable (167,711,336 samples, 0.55%)
std::__detail::_Insert_base<>::insert (99,156,610 samples, 0.33%)
std::_Hashtable<>::clear (423,205,958 samples, 1.39%)
_int_free (203,839,692 samples, 0.67%)
std::_Hashtable<>::_M_insert<> (424,733,955 samples, 1.40%)
split_to_words (1,344,770,763 samples, 4.43%)
s..
std::__detail::_Hash_node_value_base<>::_M_valptr (75,909,780 samples, 0.25%)
__libc_start_call_main (24,453,961,457 samples, 80.58%)
__libc_start_call_main
std::_Hashtable<>::_M_find_before_node (149,551,611 samples, 0.49%)
__gnu_cxx::new_allocator<>::construct<> (70,972,158 samples, 0.23%)
std::_Hashtable<>::_M_bucket_index (123,404,570 samples, 0.41%)
std::locale::id::_M_id (61,349,979 samples, 0.20%)
computeTransformationCost (24,453,961,457 samples, 80.58%)
computeTransformationCost
std::_Hashtable<>::~_Hashtable (543,107,801 samples, 1.79%)
std::unordered_set<>::insert (2,141,553,783 samples, 7.06%)
std..
std::__detail::_AllocNode<>::operator (386,054,162 samples, 1.27%)
std::_Hashtable<>::begin (86,376,117 samples, 0.28%)
std::__detail::_Mod_range_hashing::operator (60,451,271 samples, 0.20%)
std::_Hashtable<>::_M_insert_unique_node (108,863,485 samples, 0.36%)
computeTransformationCost (126,764,171 samples, 0.42%)
split_to_words (175,141,782 samples, 0.58%)
std::__detail::_Insert_base<>::insert (450,113,154 samples, 1.48%)
std::set_intersection<> (87,524,660 samples, 0.29%)
std::unordered_set<>::insert (793,329,411 samples, 2.61%)
std::_Hashtable<>::_M_rehash (130,613,483 samples, 0.43%)
std::__detail::_Hash_code_base<>::_M_hash_code (56,257,656 samples, 0.19%)
std::_Hashtable<>::_Hashtable (131,660,355 samples, 0.43%)
std::__detail::_Hashtable_alloc<>::_M_allocate_node<> (564,646,394 samples, 1.86%)
std::_Hashtable<>::_M_insert<> (76,179,591 samples, 0.25%)
__memmove_avx_unaligned_erms (230,723,935 samples, 0.76%)
std::getline<> (753,504,133 samples, 2.48%)
split_to_words (501,026,877 samples, 1.65%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node (344,273,350 samples, 1.13%)
std::__detail::_Hashtable_base<>::_M_equals (88,681,943 samples, 0.29%)
std::_Hashtable<>::_M_find_node (163,209,963 samples, 0.54%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_nodes (408,170,731 samples, 1.35%)
std::_Hashtable<>::_M_bucket_index (218,176,566 samples, 0.72%)
std::__set_intersection<> (98,466,584 samples, 0.32%)
std::_Hashtable<>::_M_insert<> (124,805,695 samples, 0.41%)
std::_Hashtable<>::_M_insert_bucket_begin (63,451,314 samples, 0.21%)
std::_Hashtable<>::_M_insert_bucket_begin (241,297,481 samples, 0.80%)
std::__set_intersection<> (190,144,026 samples, 0.63%)
std::__set_intersection<> (338,723,519 samples, 1.12%)
std::_Hashtable<>::clear (691,022,351 samples, 2.28%)
std::use_facet<> (205,794,401 samples, 0.68%)
std::_Hashtable<>::_M_insert<> (688,669,727 samples, 2.27%)
std::_Hashtable<>::~_Hashtable (324,241,217 samples, 1.07%)
std::_Hashtable<>::_M_insert<> (87,045,449 samples, 0.29%)
std::__detail::_Hash_code_base<>::_M_bucket_index (60,451,271 samples, 0.20%)
std::locale::id::_M_id (61,472,650 samples, 0.20%)
std::_Hashtable<>::_M_find_before_node (76,372,739 samples, 0.25%)
std::_Hashtable<>::_M_insert_unique_node (212,702,935 samples, 0.70%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node (88,305,503 samples, 0.29%)
std::__detail::_Prime_rehash_policy::_M_next_bkt (81,952,676 samples, 0.27%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_buckets (85,974,159 samples, 0.28%)
std::unordered_set<>::insert (475,565,284 samples, 1.57%)
std::__detail::_Hash_node_value_base<>::_M_v (68,046,232 samples, 0.22%)
switch_cost_similarity (4,233,040,676 samples, 13.95%)
switch_co..
computeTransformationCost (24,453,961,457 samples, 80.58%)
computeTransformationCost
std::__detail::_Hash_node_value_base<>::_M_v (88,510,711 samples, 0.29%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node_ptr (144,117,883 samples, 0.47%)
computeTransformationCost (24,366,304,494 samples, 80.29%)
computeTransformationCost
std::__detail::_Insert_base<>::insert (76,179,591 samples, 0.25%)
std::_Hashtable<>::_M_rehash_aux (63,124,509 samples, 0.21%)
__gnu_cxx::new_allocator<>::allocate (62,912,115 samples, 0.21%)
computeTransformationCost (6,711,267,601 samples, 22.12%)
computeTransform..
std::__detail::_Hashtable_alloc<>::_M_node_allocator (83,152,891 samples, 0.27%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node_ptr (146,900,738 samples, 0.48%)
std::_Hashtable<>::_M_insert_unique_node (465,566,906 samples, 1.53%)
all (30,346,196,639 samples, 100%)
__gnu_cxx::__ops::_Iter_less_iter::operator (194,438,111 samples, 0.64%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node (307,553,326 samples, 1.01%)
std::unordered_set<>::begin (111,750,375 samples, 0.37%)
std::__detail::_Hash_code_base<>::_M_bucket_index (200,305,488 samples, 0.66%)
std::__detail::_Prime_rehash_policy::_M_need_rehash (74,392,661 samples, 0.25%)
computeTransformationCost (19,206,826,621 samples, 63.29%)
computeTransformationCost
std::__detail::_Hash_code_base<>::_M_hash_code (297,636,359 samples, 0.98%)
std::_Hashtable<>::~_Hashtable (300,131,045 samples, 0.99%)
std::unordered_set<>::insert (2,528,115,642 samples, 8.33%)
std:..
std::_Hashtable<>::_M_find_before_node (132,793,443 samples, 0.44%)
malloc (556,806,813 samples, 1.83%)
std::use_facet<> (238,098,461 samples, 0.78%)
std::_Hashtable<>::_M_deallocate_buckets (136,473,314 samples, 0.45%)
std::__cxx11::basic_string<>::_M_append (84,900,733 samples, 0.28%)
std::getline<> (209,120,438 samples, 0.69%)
__memmove_avx_unaligned_erms (85,279,360 samples, 0.28%)
std::__detail::_Prime_rehash_policy::_M_need_rehash (88,533,186 samples, 0.29%)
std::_Hashtable<>::_M_allocate_buckets (132,829,072 samples, 0.44%)
std::locale::~locale (75,205,086 samples, 0.25%)
std::__detail::_Hashtable_alloc<>::_M_allocate_node<> (491,532,595 samples, 1.62%)
std::__detail::_Hash_code_base<>::_M_hash_code (138,808,125 samples, 0.46%)
__gnu_cxx::__ops::_Iter_less_iter::operator (63,364,201 samples, 0.21%)
std::__detail::_Mod_range_hashing::operator (95,258,960 samples, 0.31%)
std::__cxx11::basic_istringstream<>::basic_istringstream (147,083,543 samples, 0.48%)
std::_Hashtable<>::_M_insert_bucket_begin (119,915,397 samples, 0.40%)
findBestCorrespondingTraces (24,453,961,457 samples, 80.58%)
findBestCorrespondingTraces
split_to_words (2,177,849,304 samples, 7.18%)
spl..
std::_Hashtable<>::clear (274,908,176 samples, 0.91%)
std::_Hashtable<>::_M_rehash (142,383,899 samples, 0.47%)
__memcmp_avx2_movbe (343,668,601 samples, 1.13%)
[unknown] (1,237,716,729 samples, 4.08%)
[..
std::__detail::_AllocNode<>::operator (86,784,263 samples, 0.29%)
std::__cxx11::basic_string<>::_M_construct<> (108,694,513 samples, 0.36%)
std::__detail::_Insert_base<>::insert (339,397,470 samples, 1.12%)
std::_Hashtable<>::~_Hashtable (72,850,888 samples, 0.24%)
std::_Hashtable<>::_M_find_node (83,701,224 samples, 0.28%)
std::_Hashtable<>::_M_deallocate_buckets (68,305,791 samples, 0.23%)
std::unordered_set<>::~unordered_set (878,548,943 samples, 2.90%)
std::set_intersection<> (202,832,003 samples, 0.67%)
switch_cost_similarity (162,118,468 samples, 0.53%)
std::__detail::_Mod_range_hashing::operator (129,908,989 samples, 0.43%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_nodes (113,683,154 samples, 0.37%)
computeTransformationCost (24,453,961,457 samples, 80.58%)
computeTransformationCost
std::_Hashtable<>::_M_insert<> (2,003,721,333 samples, 6.60%)
std..
std::__detail::_Hash_code_base<>::_M_hash_code (202,692,147 samples, 0.67%)
switch_cost_similarity (3,540,158,200 samples, 11.67%)
switch_..
std::__detail::_Mod_range_hashing::operator (162,303,894 samples, 0.53%)
std::_Hashtable<>::_M_insert<> (2,368,428,522 samples, 7.80%)
std:..
std::_Hashtable<>::_M_bucket_index (234,233,890 samples, 0.77%)
switch_cost_similarity (520,269,816 samples, 1.71%)
std::__detail::_Hash_code_base<>::_M_bucket_index (129,908,989 samples, 0.43%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_nodes (657,997,253 samples, 2.17%)
std::allocator_traits<>::destroy<> (75,001,384 samples, 0.25%)
std::_Hashtable<>::_M_insert<> (1,412,341,981 samples, 4.65%)
s..
virtual thunk to std::__cxx11::basic_istringstream<>::~basic_istringstream (382,616,945 samples, 1.26%)
std::pair<>::pair<> (60,804,509 samples, 0.20%)
std::_Hash_bytes (97,793,476 samples, 0.32%)
std::_Hashtable<>::_M_allocate_buckets (60,591,065 samples, 0.20%)
std::_Hashtable<>::~_Hashtable (865,030,279 samples, 2.85%)
std::set_intersection<> (334,484,716 samples, 1.10%)
std::_Hashtable<>::_M_insert<> (1,205,154,036 samples, 3.97%)
s..
std::unordered_set<>::~unordered_set (622,516,962 samples, 2.05%)
std::unordered_set<>::unordered_set (131,660,355 samples, 0.43%)
std::unordered_set<>::~unordered_set (336,907,994 samples, 1.11%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_nodes (220,696,686 samples, 0.73%)
std::set_intersection<> (63,229,687 samples, 0.21%)
std::__detail::_Hashtable_alloc<>::_M_allocate_buckets (97,670,834 samples, 0.32%)
std::_Hashtable<>::_M_find_node (69,154,833 samples, 0.23%)
__gnu_cxx::__ops::_Iter_less_iter::operator (308,715,933 samples, 1.02%)
std::__detail::_Insert_base<>::insert (2,245,378,259 samples, 7.40%)
std:..
std::_Hashtable<>::_M_find_before_node (63,238,023 samples, 0.21%)
std::_Hashtable<>::_M_bucket_index (111,963,585 samples, 0.37%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_nodes (372,913,020 samples, 1.23%)
std::__set_intersection<> (309,744,023 samples, 1.02%)
std::_Hashtable<>::_M_rehash (109,724,620 samples, 0.36%)
std::unordered_set<>::unordered_set (65,622,007 samples, 0.22%)
std::__set_intersection<> (230,638,748 samples, 0.76%)
std::__detail::_AllocNode<>::operator (100,760,402 samples, 0.33%)
std::pair<>::pair<> (96,045,259 samples, 0.32%)
switch_cost_similarity (319,265,493 samples, 1.05%)
std::unordered_set<>::insert (162,601,667 samples, 0.54%)
std::_Hashtable<>::_M_insert<> (2,118,411,953 samples, 6.98%)
std..
std::hash<>::operator (168,937,520 samples, 0.56%)
std::allocator_traits<>::construct<> (81,079,014 samples, 0.27%)
std::__cxx11::basic_string<>::_M_append (150,397,877 samples, 0.50%)
std::__detail::_Hashtable_alloc<>::_M_node_allocator (95,731,141 samples, 0.32%)
switch_cost_similarity (802,742,524 samples, 2.65%)
std::__detail::_Insert_base<>::insert (2,479,588,929 samples, 8.17%)
std:..
std::_Hashtable<>::_M_insert_unique_node (86,896,404 samples, 0.29%)
std::_Hashtable<>::clear (456,995,837 samples, 1.51%)
std::allocator_traits<>::construct<> (87,129,532 samples, 0.29%)
std::_Hashtable<>::_M_insert_bucket_begin (125,616,017 samples, 0.41%)
std::__detail::_Hashtable_alloc<>::_M_allocate_node<> (261,119,834 samples, 0.86%)
std::_Hashtable<>::_M_deallocate_buckets (116,940,631 samples, 0.39%)
std::allocator_traits<>::allocate (86,150,391 samples, 0.28%)
std::__detail::_Hash_node<>::_Hash_node (75,372,735 samples, 0.25%)
std::__detail::_Node_iterator<>::operator* (175,519,561 samples, 0.58%)
std::__detail::_Hashtable_alloc<>::_M_allocate_node<> (86,784,263 samples, 0.29%)
std::istream::sentry::sentry (78,856,500 samples, 0.26%)
std::_Hashtable<>::_M_find_before_node (113,689,353 samples, 0.37%)
computeTransformationCost (3,073,970,551 samples, 10.13%)
comput..
std::_Hash_bytes (81,464,817 samples, 0.27%)
std::allocator_traits<>::destroy<> (58,358,488 samples, 0.19%)
std::unordered_set<>::~unordered_set (555,742,256 samples, 1.83%)
__gnu_cxx::__ops::_Iter_less_iter::operator (210,208,081 samples, 0.69%)
std::_Hashtable<>::_M_allocate_buckets (118,888,235 samples, 0.39%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_buckets (67,586,681 samples, 0.22%)
std::pair<>::pair<> (85,969,316 samples, 0.28%)
std::_Hashtable<>::_M_find_before_node (57,929,998 samples, 0.19%)
std::_Hashtable<>::_M_insert_bucket_begin (108,405,117 samples, 0.36%)
std::_Hashtable<>::_M_bucket_index (215,146,244 samples, 0.71%)
std::_Hash_bytes (156,350,910 samples, 0.52%)
std::pair<>::pair<> (62,294,417 samples, 0.21%)
split_to_words (2,647,642,707 samples, 8.72%)
split..
std::__detail::_Hashtable_alloc<>::_M_deallocate_node (168,246,199 samples, 0.55%)
split_to_words (99,156,610 samples, 0.33%)
std::unordered_set<>::insert (339,397,470 samples, 1.12%)
split_to_words (793,329,411 samples, 2.61%)
std::unordered_set<>::~unordered_set (300,131,045 samples, 0.99%)
std::_Hash_bytes (88,482,448 samples, 0.29%)
std::__detail::_Mod_range_hashing::operator (73,847,216 samples, 0.24%)
std::unordered_set<>::unordered_set (57,621,860 samples, 0.19%)
__gnu_cxx::__ops::_Iter_less_iter::operator (108,942,424 samples, 0.36%)
std::__detail::_Node_iterator<>::operator* (85,297,297 samples, 0.28%)
computeTransformationCost (24,441,283,512 samples, 80.54%)
computeTransformationCost
std::set_intersection<> (381,828,222 samples, 1.26%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_nodes (257,547,444 samples, 0.85%)
std::set_intersection<> (448,108,350 samples, 1.48%)
std::_Hashtable<>::_M_rehash_aux (130,613,483 samples, 0.43%)
std::__detail::_Hash_code_base<>::_M_bucket_index (164,701,875 samples, 0.54%)
std::_Hashtable<>::_M_rehash_aux (98,392,788 samples, 0.32%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node_ptr (250,737,241 samples, 0.83%)
std::_Hashtable<>::_M_allocate_buckets (81,873,514 samples, 0.27%)
std::_Hashtable<>::_M_deallocate_buckets (84,425,252 samples, 0.28%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_nodes (262,214,151 samples, 0.86%)
std::__detail::_Node_iterator<>::operator* (63,320,955 samples, 0.21%)
std::allocator_traits<>::construct<> (107,792,695 samples, 0.36%)
std::_Hashtable<>::_M_insert<> (339,397,470 samples, 1.12%)
std::__detail::_Insert_base<>::insert (2,116,582,807 samples, 6.97%)
std..
std::istream::sentry::sentry (355,999,704 samples, 1.17%)
std::hash<>::operator (123,752,988 samples, 0.41%)
__gnu_cxx::__aligned_buffer<>::_M_ptr (63,196,228 samples, 0.21%)
std::set_intersection<> (230,638,748 samples, 0.76%)
std::hash<>::operator (237,155,336 samples, 0.78%)
std::__detail::_Hash_node_value_base<>::_M_valptr (62,792,918 samples, 0.21%)
std::min<> (59,354,158 samples, 0.20%)
std::_Hashtable<>::clear (566,646,944 samples, 1.87%)
_int_free (305,422,852 samples, 1.01%)
std::_Hashtable<>::_M_insert_unique_node (235,312,726 samples, 0.78%)
std::unordered_set<>::insert (76,179,591 samples, 0.25%)
std::_Hashtable<>::_Hashtable (72,204,398 samples, 0.24%)
std::__detail::_Mod_range_hashing::operator (109,709,329 samples, 0.36%)
std::__detail::_AllocNode<>::operator (325,962,183 samples, 1.07%)
std::allocator_traits<>::construct<> (55,437,534 samples, 0.18%)
std::allocator_traits<>::allocate (72,023,088 samples, 0.24%)
std::_Hashtable<>::_M_find_before_node (58,524,291 samples, 0.19%)
std::_Hashtable<>::_M_find_node (76,372,739 samples, 0.25%)
std::_Hashtable<>::_M_deallocate_buckets (86,111,964 samples, 0.28%)
split_to_words (352,068,745 samples, 1.16%)
std::unordered_set<>::insert (2,283,137,477 samples, 7.52%)
std:..
std::__detail::_Hashtable_ebo_helper<>::_M_get (58,698,346 samples, 0.19%)
std::_Hashtable<>::_M_rehash_aux (142,383,899 samples, 0.47%)
std::_Hashtable<>::~_Hashtable (585,174,128 samples, 1.93%)
__gnu_cxx::__ops::_Iter_less_iter::operator (229,344,399 samples, 0.76%)
std::__detail::_Hash_code_base<>::_M_hash_code (120,415,631 samples, 0.40%)
std::allocator_traits<>::construct<> (145,422,634 samples, 0.48%)
std::__detail::_AllocNode<>::operator (574,531,531 samples, 1.89%)
std::_Hashtable<>::_M_bucket_index (142,042,524 samples, 0.47%)
std::__detail::_Hash_node<>::_Hash_node (61,751,902 samples, 0.20%)
std::set_intersection<> (299,099,400 samples, 0.99%)
std::__detail::_Hash_code_base<>::_M_hash_code (250,108,645 samples, 0.82%)
std::_Hashtable<>::_M_find_node (126,421,684 samples, 0.42%)
std::hash<>::operator (75,637,241 samples, 0.25%)
switch_cost_similarity (2,601,183,389 samples, 8.57%)
switc..
switch_cost_similarity (62,357,892 samples, 0.21%)
computeTransformationCost (24,191,560,760 samples, 79.72%)
computeTransformationCost
std::allocator_traits<>::deallocate (114,124,851 samples, 0.38%)
std::unordered_set<>::unordered_set (200,874,274 samples, 0.66%)
std::_Hashtable<>::_M_allocate_buckets (63,124,509 samples, 0.21%)
std::_Hashtable<>::_M_find_node (145,259,645 samples, 0.48%)
[unknown] (858,627,895 samples, 2.83%)
computeTransformationCost (15,532,491,252 samples, 51.18%)
computeTransformationCost
std::allocator_traits<>::allocate (112,231,155 samples, 0.37%)
std::unordered_set<>::insert (1,570,122,331 samples, 5.17%)
st..
std::_Hashtable<>::_M_deallocate_buckets (68,305,791 samples, 0.23%)
std::allocator_traits<>::destroy<> (70,836,055 samples, 0.23%)
std::__detail::_Mod_range_hashing::operator (139,388,038 samples, 0.46%)
std::_Hashtable<>::clear (256,491,786 samples, 0.85%)
computeTransformationCost (24,441,283,512 samples, 80.54%)
computeTransformationCost
std::__detail::_Insert_base<>::insert (755,757,173 samples, 2.49%)
std::_Hashtable<>::_M_deallocate_buckets (91,678,547 samples, 0.30%)
std::unordered_set<>::~unordered_set (385,462,125 samples, 1.27%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node_ptr (120,989,539 samples, 0.40%)
std::__detail::_Hash_node<>::_M_next (59,129,159 samples, 0.19%)
std::_Hashtable<>::_M_deallocate_buckets (98,536,509 samples, 0.32%)
std::__detail::_Node_iterator<>::operator++ (59,023,306 samples, 0.19%)
std::_Hash_bytes (136,652,898 samples, 0.45%)
std::unordered_set<>::unordered_set (94,846,492 samples, 0.31%)
std::__detail::_Mod_range_hashing::operator (75,659,604 samples, 0.25%)
switch_cost_similarity (114,036,176 samples, 0.38%)
std::allocator_traits<>::allocate (115,951,848 samples, 0.38%)
__memchr_avx2 (232,213,985 samples, 0.77%)
std::_Hashtable<>::_Scoped_node::_Scoped_node (58,794,287 samples, 0.19%)
std::_Hashtable<>::_M_deallocate_buckets (96,381,700 samples, 0.32%)
std::__detail::_Hashtable_alloc<>::_M_allocate_node<> (262,981,575 samples, 0.87%)
std::basic_ios<>::init (74,272,696 samples, 0.24%)
std::_Hashtable<>::_M_bucket_index (60,451,271 samples, 0.20%)
std::__detail::_Hashtable_alloc<>::_M_allocate_node<> (200,135,425 samples, 0.66%)
std::__detail::_Hash_code_base<>::_M_hash_code (60,903,385 samples, 0.20%)
std::_Hashtable<>::_M_deallocate_buckets (62,457,678 samples, 0.21%)
std::hash<>::operator (140,394,096 samples, 0.46%)
std::__detail::_AllocNode<>::operator (627,073,059 samples, 2.07%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node_ptr (86,689,031 samples, 0.29%)
std::_Hashtable<>::_M_insert_unique_node (514,418,993 samples, 1.70%)
std::unordered_set<>::~unordered_set (126,417,939 samples, 0.42%)
std::__detail::_Insert_base<>::insert (1,268,856,814 samples, 4.18%)
s..
std::_Hashtable<>::_M_find_before_node (125,288,604 samples, 0.41%)
std::unordered_set<>::~unordered_set (85,420,771 samples, 0.28%)
std::_Hashtable<>::clear (113,683,154 samples, 0.37%)
split_to_words (76,179,591 samples, 0.25%)
std::__detail::_Hashtable_alloc<>::_M_allocate_node<> (75,356,866 samples, 0.25%)
std::unordered_set<>::~unordered_set (814,581,681 samples, 2.68%)
std::_Hashtable<>::_M_rehash_aux (167,818,950 samples, 0.55%)
std::_Hash_bytes (63,107,299 samples, 0.21%)
[libstdc++.so.6.0.30] (52,764,559 samples, 0.17%)
std::__detail::_Hash_code_base<>::_M_hash_code (211,413,695 samples, 0.70%)
computeTransformationCost (11,140,044,930 samples, 36.71%)
computeTransformationCost
std::__detail::_Hashtable_alloc<>::_M_deallocate_node_ptr (74,762,322 samples, 0.25%)
std::_Hashtable<>::_M_insert_unique_node (339,379,958 samples, 1.12%)
main (24,453,961,457 samples, 80.58%)
main
std::_Hashtable<>::_M_bucket_index (75,659,604 samples, 0.25%)
std::__detail::_Hashtable_alloc<>::_Hashtable_alloc (56,901,558 samples, 0.19%)
std::_Hashtable<>::_M_insert<> (1,947,768,414 samples, 6.42%)
std..
std::_Hashtable<>::_M_insert_unique_node (574,692,200 samples, 1.89%)
std::__set_intersection<> (74,863,645 samples, 0.25%)
computeTransformationCost (23,274,361,450 samples, 76.70%)
computeTransformationCost
std::__detail::_Prime_rehash_policy::_M_next_bkt (62,381,385 samples, 0.21%)
std::__detail::_Node_iterator<>::operator* (137,949,749 samples, 0.45%)
std::__detail::_Node_iterator<>::operator* (159,869,200 samples, 0.53%)
std::__detail::_AllocNode<>::operator (541,116,027 samples, 1.78%)
std::__detail::_Hashtable_alloc<>::_M_node_allocator (58,259,447 samples, 0.19%)
std::_Hashtable<>::_M_insert_unique_node (52,727,755 samples, 0.17%)
std::__detail::_Hashtable_alloc<>::_M_allocate_node<> (473,200,095 samples, 1.56%)
std::_Hashtable<>::_M_bucket_index (132,472,304 samples, 0.44%)
split_to_words (1,689,743,816 samples, 5.57%)
sp..
std::__detail::_Hash_code_base<>::_M_bucket_index (130,863,683 samples, 0.43%)
[unknown] (3,288,808,675 samples, 10.84%)
[unkno..
std::_Hashtable<>::~_Hashtable (360,080,072 samples, 1.19%)
split_to_words (2,199,364,245 samples, 7.25%)
spl..
computeTransformationCost (24,453,961,457 samples, 80.58%)
computeTransformationCost
computeTransformationCost (24,453,961,457 samples, 80.58%)
computeTransformationCost
std::_Hashtable<>::_M_bucket_index (63,066,059 samples, 0.21%)
computeTransformationCost (21,903,055,082 samples, 72.18%)
computeTransformationCost
std::_Hashtable<>::~_Hashtable (776,668,345 samples, 2.56%)
std::_Hashtable<>::~_Hashtable (113,683,154 samples, 0.37%)
std::__detail::_Hash_node_value_base<>::_M_v (86,104,875 samples, 0.28%)
[libstdc++.so.6.0.30] (149,539,533 samples, 0.49%)
std::_Hashtable<>::_M_insert_unique_node (55,078,692 samples, 0.18%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node (208,124,533 samples, 0.69%)
std::__set_intersection<> (410,206,877 samples, 1.35%)
[unknown] (382,616,945 samples, 1.26%)
std::_Hashtable<>::_M_find_node (149,551,611 samples, 0.49%)
switch_cost_similarity (4,284,832,188 samples, 14.12%)
switch_co..
std::__detail::_Hashtable_alloc<>::_M_deallocate_nodes (542,109,269 samples, 1.79%)
std::_Hashtable<>::_M_rehash (180,468,625 samples, 0.59%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node_ptr (62,707,458 samples, 0.21%)
std::__detail::_Hash_code_base<>::_M_bucket_index (110,730,218 samples, 0.36%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node (187,269,103 samples, 0.62%)
std::__cxx11::basic_stringbuf<>::~basic_stringbuf (1,237,716,729 samples, 4.08%)
s..
std::__detail::_Hash_code_base<>::_M_hash_code (298,542,530 samples, 0.98%)
std::set_intersection<> (98,466,584 samples, 0.32%)
__gnu_cxx::__ops::_Iter_less_iter::operator (139,661,595 samples, 0.46%)
std::__detail::_Hash_code_base<>::_M_bucket_index (75,659,604 samples, 0.25%)
std::_Hashtable<>::clear (270,145,744 samples, 0.89%)
std::unordered_set<>::insert (1,268,856,814 samples, 4.18%)
s..
split_to_words (2,509,273,204 samples, 8.27%)
spli..
std::__detail::_Insert_base<>::insert (2,006,227,148 samples, 6.61%)
std..
std::ios_base::_M_init (98,903,662 samples, 0.33%)
std::__detail::_Node_iterator<>::operator* (94,573,196 samples, 0.31%)
std::hash<>::operator (161,839,803 samples, 0.53%)
std::__detail::_Mod_range_hashing::operator (74,814,635 samples, 0.25%)
std::unordered_set<>::begin (86,551,405 samples, 0.29%)
std::__detail::_Insert_base<>::insert (149,932,813 samples, 0.49%)
computeTransformationCost (954,919,235 samples, 3.15%)
switch_cost_similarity (1,322,470,505 samples, 4.36%)
s..
std::allocator_traits<>::deallocate (59,474,825 samples, 0.20%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node (286,410,481 samples, 0.94%)
std::__detail::_Hash_code_base<>::_M_bucket_index (120,596,862 samples, 0.40%)
std::__detail::_AllocNode<>::operator (307,541,820 samples, 1.01%)
std::__set_intersection<> (299,099,400 samples, 0.99%)
std::_Hashtable<>::_M_rehash (75,841,365 samples, 0.25%)
std::allocator_traits<>::construct<> (107,111,769 samples, 0.35%)
std::basic_ios<>::operator bool (69,111,499 samples, 0.23%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node (489,435,965 samples, 1.61%)
std::__detail::_Hashtable_alloc<>::_M_deallocate_node_ptr (95,651,666 samples, 0.32%)
std::__detail::_Insert_base<>::insert (1,570,122,331 samples, 5.17%)
st..
std::__detail::_Hash_code_base<>::_M_bucket_index (74,814,635 samples, 0.25%)
cfree@GLIBC_2.2.5 (211,951,913 samples, 0.70%)
std::unordered_set<>::insert (2,031,112,515 samples, 6.69%)
std..
std::_Hashtable<>::_M_rehash (75,741,602 samples, 0.25%)
switch_cost_similarity (2,045,261,120 samples, 6.74%)
swi..
switch_cost_similarity (3,526,959,827 samples, 11.62%)
switch_..
std::unordered_set<>::end (60,228,776 samples, 0.20%)
std::allocator_traits<>::construct<> (149,358,068 samples, 0.49%)
std::__detail::_Hashtable_alloc<>::_M_allocate_buckets (95,127,249 samples, 0.31%)
computeTransformationCost (23,847,307,986 samples, 78.58%)
computeTransformationCost
std::unordered_set<>::insert (99,156,610 samples, 0.33%)
computeTransformationCost (24,453,961,457 samples, 80.58%)
computeTransformationCost
std::__detail::_Hashtable_alloc<>::_M_allocate_node<> (336,728,745 samples, 1.11%)
std::__detail::_AllocNode<>::operator (200,135,425 samples, 0.66%)
Threshold:
Min:
Max:
Show:
Baseline
Target
Incr (vs base)
Equal
Decr (vs base)
[+]
[-]
Help / Tips
[-]
[+]
Tip 1
Use the tools at top-right corner of the graph to expand/fold the callers/callees.
Tip 2
Wide red edges are (generally) bad; wide green edges are (generally) good.